Mit csinál a „szigorú használata” a JavaScript-ben, és mi az oka annak?

Ez a cikk a Javascript szigorú módjáról szólhat: John Resig - ECMAScript 5 szigorú mód, JSON és még sok más
Néhány érdekes részt idézve:
A szigorú mód az ECMAScript 5 új szolgáltatása, amely lehetővé teszi, hogy egy programot vagy funkciót "szigorú" működési környezetben helyezzen el. Ez a szigorú kontextus megakadályozza bizonyos cselekvések végrehajtását, és további kivételeket vet fel.
És:
A szigorú mód pár módon segít:
Elkap néhány általános kódoló bloopert, kivételt dobva.
Megelőzi vagy eldobja a hibákat, ha viszonylag "nem biztonságos" műveleteket hajtanak végre (például hozzáférést kapnak a globális objektumhoz).
Letiltja a zavaró vagy rosszul átgondolt funkciókat.
Vegye figyelembe azt is, hogy a "szigorú módot" alkalmazhatja az egész fájlra ... Vagy használhatja csak egy adott funkcióhoz (még mindig idézem John Resig cikkét):
// Nem szigorú kód ...
(funkció(){
"használja szigorúan";
// Szigorúan határozza meg könyvtárát ...
}) ();
// Nem szigorú kód ...
Ami hasznos lehet, ha régi és új kódokat kell kevernie ;-)
Tehát feltételezem, hogy ez egy kicsit hasonlít a Perl-ben használt "szigorú használatra" (innen a név?): Kevesebb hibát okoz, mivel több olyan dolgot észlel, amely töréshez vezethet.
A szigorú módot most minden fő böngésző támogatja.
A natív ECMAScript modulokban (importálási és exportálási utasításokkal) és az ES6 osztályokban a szigorú mód mindig engedélyezett és nem kapcsolható ki.
|
Ez az ECMAScript 5 új szolgáltatása. John Resig szép összefoglalót készített róla.
Ez csak egy karakterlánc, amelyet a JavaScript fájljaiba helyezett (akár a fájl tetején, akár a függvény belsejében), amely így néz ki:
"használja szigorúan";
A kódba most beírva nem okozhat problémát a jelenlegi böngészők, mivel ez csak egy karakterlánc. A jövőben problémákat okozhat a kódoddal, ha a kódod sérti a pragmát. Például, ha jelenleg foo = "bar" van, anélkül, hogy először meghatároznád a foo-t, akkor a kódod meghiúsulni kezd ... ami véleményem szerint jó dolog.
|
A "szigorú használat" kijelentés; utasítja a böngészőt, hogy használja a szigorú módot, amely a JavaScript csökkentett és biztonságosabb szolgáltatáskészlete.
Jellemzők listája (nem teljes)
Nem engedélyezi a globális változókat. (A változók nevében hiányzik a var deklarációk és elírások
A csendes sikertelen hozzárendelések szigorú módban hibát okoznak (NaN = 5 hozzárendelése;)
A törlhetetlen tulajdonságok törlésének kísérletei eldobják (Object.prototype törlése)
Megköveteli, hogy az objektum literáljának összes tulajdonságneve egyedi legyen (var x = {x1: "1", x1: "2"})
A függvényparaméter-neveknek egyedinek kell lenniük (függvényösszeg (x, x) {...})
Megtiltja az oktális szintaxist (var x = 023; egyes fejlesztők tévesen feltételezik, hogy az előző nulla nem változtat a számon.)
A kulcsszóval tiltja
szigorú módban az eval nem vezet be új változókat
Tiltja a sima nevek törlését (törölje x;)
Tiltja az eval és az argumentumok bármilyen formában történő megkötését vagy kiosztását
A szigorú mód nem álnevezi az argumentumok objektumának tulajdonságait a formális paraméterekkel. (azaz függvényösszegben (a, b) {return argumentumok [0] + b;} Ez azért működik, mert a [0] argumentumok a-hoz vannak kötve stb.
argumentumok.callee nem támogatott
[Ref: Szigorú mód, Mozilla Developer Network]
|
Ha az emberek aggódnak a szigorú használat miatt, érdemes megnézni ezt a cikket:
ECMAScript 5 „Szigorú mód” támogatás a böngészőkben. Mit jelent ez? NovoGeek.com - Krishna weblogja
Beszél a böngésző támogatásáról, de ami még fontosabb, hogyan kell biztonságosan kezelni:
függvény isStrictMode () {
vissza! ezt;
}
/ *
hamis értéket ad vissza, mivel az 'ez' globális objektumra és
A '! ez' hamissá válik
* /
függvény isStrictMode () {
"használja szigorúan";
vissza! ezt;
}
/ *
igaz értéket ad vissza, mivel szigorú módban az „ez” kulcsszó
a hagyományos JS-sel ellentétben nem utal globális objektumra.
Tehát itt a "ez" nincs meghatározva, és a "! Ez" igaz lesz.
* /
|
Vigyázat: mindannyian, keményen feltöltődő programozók: a "szigorú használat" alkalmazása a meglévő kódra veszélyes lehet! Ez nem valami jó érzésű, boldog arcú matrica, amellyel rápofozhat a kódra, hogy „jobb” legyen. A "szigorú használat" pragma használatával a böngésző hirtelen olyan véletlenszerű helyeket dob ​​el, amelyeket még soha nem dobott meg, csak azért, mert azon a helyen olyan dolgot csinál, amelyet az alapértelmezett / laza JavaScript boldogan megenged, de szigorú JavaScript irtózik! Előfordulhat, hogy szigorúsági megsértések rejlenek a kódban ritkán használt hívásokban, amelyek csak akkor vetnek ki kivételt, ha végül futnak - mondjuk abban a termelési környezetben, amelyet a fizető ügyfelek használnak!
Ha meg fogja kezdeni a lépést, akkor érdemes átfogó egységtesztek és szigorúan konfigurált JSHint felépítési feladat mellett alkalmazni a "use szigorú" alkalmazást, amely bizonyos magabiztosságot nyújt Önnek abban, hogy a modulnak nincs sötét sarka, amely felrobbant szörnyen csak azért, mert bekapcsolta a Szigorú módot. Vagy, hé, itt van egy másik lehetőség: csak ne írja be a "use szigorú" szót egyetlen régi kódjához sem, valószínűleg így biztonságosabb, őszintén. VÉGLEGESEN NE adja hozzá a "use szigorú" szót olyan modulokhoz, amelyek nem Ön tulajdonában vannak vagy amelyekkarbantartani, mint harmadik fél moduljait.
Úgy gondolom, hogy bár halálosan ketrecben tartott állatról van szó, a "szigorú használat" jó dolog lehet, de jól kell tennie. A szigorú végrehajtás legjobb ideje, amikor a projekt zöldmezős, és a semmiből indul. Konfigurálja a JSHint / JSLint szolgáltatást az összes figyelmeztetéssel és opcióval, amilyen szorosan a csapata gyomrában gyengélkedhet, szerezzen egy jó összeállítási / tesztelési / érvényesítési rendszert a Grunt + Karma + Chai-hoz hasonlóan, és csak akkor kezdje el az összes új modulját " használja szigorúan ". Legyen kész arra, hogy orvosolja a sok csúnya hibát és figyelmeztetést. Győződjön meg róla, hogy mindenki megérti a gravitációt, ha az építést FAIL-re konfigurálja, ha a JSHint / JSLint bármilyen megsértést okoz.
A projektem nem volt zöldmezős projekt, amikor elfogadtam a "use szigorú" szót. Ennek eredményeként az IDE-m tele van piros jelekkel, mert a modulok felénél nincs "szigorú használat", és a JSHint panaszkodik emiatt. Ez egy emlékeztető számomra arról, hogy milyen refaktorálást kell végeznem a jövőben. A célom az, hogy minden hiányzó "szigorúan használjam" kijelentésem miatt vörös jelölés mentes legyek, de ez már évek múlva van.
|
A „use szigorú” használata; hirtelen nem javítja a kódot.
A JavaScript szigorú módja az ECMAScript 5 egyik jellemzője. A szigorú módot úgy engedélyezheti, hogy ezt deklarálja a szkript / funkció tetején.
„szigorúan használja”;
Amikor egy JavaScript motor meglátja ezt az irányelvet, egy speciális módban kezdi értelmezni a kódot. Ebben a módban hibák merülnek fel, amikor bizonyos kódolási gyakorlatokat észlelnek, amelyek potenciális hibákat eredményezhetnek (ez az oka a szigorú módnak).
Tekintsük ezt a példát:
var a = 365;
var b = 030;
A numerikus literálok felsorolása iránti rögeszméjükben a fejlesztő akaratlanul inicializálta a b változót egy oktális literállal. A nem szigorú mód ezt 24-es értékű numerikus literálként értelmezi (a 10. alapban). A szigorú mód azonban hibát vet.
A szigorú módú specialitások nem teljes listáját lásd ebben a válaszban.
Hol használjam a „use szigorú” kifejezést ;?
Új JavaScript alkalmazásomban: Teljesen! A szigorú mód bejelentőként használható, amikor valami hülyeséget csinál a kódjával.
A meglévő JavaScript kódomban: Valószínűleg nem! Ha a meglévő JavaScript-kód olyan utasításokat tartalmaz, amelyek szigorú módban tiltottak, az alkalmazás egyszerűen megszakad. Ha szigorú módot szeretne, készen kell állnia a hibakeresésre és a meglévő kód javítására. Ezért használja a „use szigorú” szót; hirtelen nem javítja a kódot.
Hogyan használhatom a szigorú módot?
Helyezzen be egy „szigorú használatot”; utasítás a szkript tetején:
// Fájl: myscript.js
„szigorúan használja”;
var a = 2;
....
Ne feledje, hogy a myscript.js fájlban mindent szigorúan fog értelmezni.
Vagy illesszen be egy „use szigorú” kifejezést; utasítás a függvénytest tetején:
függvény doSomething () {
„szigorúan használja”;
...
}
A doSomething lexikális funkciói között mindent szigorúan értelmezünk. A lexikai hatókör itt fontos. Például, ha a szigorú kód egy nem függvényes függvényt hív meg, akkor csak a kódot hajtja végre szigorú módban, és nem a meghívott függvényt. A jobb magyarázatért lásd ezt a választ.
Milyen dolgok tiltottak szigorú módban?
Találtam egy kedves cikket, amely több olyan dolgot ír le, amelyek szigorú módban tilosak (vegye figyelembe, hogy ez nem kizárólagos lista):
Hatály
Történelmileg a JavaScript összezavarodott a működésében
hatókörébe tartoznak. Néha úgy tűnik, hogy statikusan hatókörűek, de vannak
a funkciók arra késztetik őket, hogy úgy viselkedjenek, mint dinamikusan. Ez
zavaros, ami a programokat nehezen olvasható és érthetővé teszi.
A félreértés hibákat okoz. A teljesítmény szempontjából is problémát jelent.
A statikus hatókör lehetővé tenné a változó kötését a fordításkor
idő, de a dinamikus hatókör követelménye azt jelenti, hogy kötelezőnek kell lennie
futási időre halasztva, amely jelentős teljesítményt nyújt
büntetés.
A szigorú mód megköveteli, hogy az összes változó kötése statikusan történjen.
Ez azt jelenti, hogy a korábban dinamikus kötést igénylő funkciók
meg kell szüntetni vagy módosítani kell. Pontosabban a with utasítás az
megszűnik, és az eval funkció képes manipulálni a
a hívó környezete szigorúan korlátozott.
A szigorú kód egyik előnye, hogy olyan eszközök, mint a YUI Compressor
jobb munkát végezhet annak feldolgozásakor.
Implicit globális változók
A JavaScript globális változókat tartalmaz. Ha
nem kifejezetten deklarál egy változót, a globális változó az
hallgatólagosan neked nyilatkozott. Ez megkönnyíti a programozást
kezdőknek, mert elhanyagolhatják alapvető háztartásuk egy részét
házimunkát. De ez sokkal nagyobbá teszi a nagyobb programok kezelését
nehéz és jelentősen rontja a megbízhatóságot. Tehát szigorúan
módban az implicit globális változók már nem jönnek létre. Neked kellene
kifejezetten deklarálja az összes változót.
Globális szivárgás
Számos helyzet okozhatja ezt
hogy a globális objektumhoz legyen kötve. Például, ha elfelejtette
adja meg az új előtagot konstruktor meghívásakorfunkció, a
konstruktor ez váratlanul kötődik a globális objektumhoz, tehát
egy új objektum inicializálása helyett csendben lesz
a globális változók manipulálása. Ezekben a helyzetekben a szigorú mód lesz
ehelyett ezt definiálatlanhoz köti, aminek hatására a konstruktor
dobjon kivételt, lehetővé téve a hiba sok észlelését
hamarabb.
Zajos kudarc
A JavaScript mindig rendelkezett csak olvasható tulajdonságokkal, de Ön
csak az ES5 Object.createProperty fájljáig hozhatta létre őket
funkció kitette ezt a képességet. Ha megpróbált értéket rendelni
csak olvasható tulajdonságra, ez némán kudarcot vallana. A megbízás megtenné
nem változtatja meg az ingatlan értékét, de a program úgy haladna
bár volt. Ez az integritás veszélye, amely a programokat okozhatja
következetlen állapotba kerül. Szigorú módban megpróbálja megváltoztatni a
csak olvasható tulajdonság kivételt hoz.
Octal
A számok oktális (vagy 8. alap) ábrázolása rendkívül nagy volt
hasznos, ha gépszintű programozást végeznek olyan gépeken, amelyeknek a szava
A méretek a 3-szorosok voltak. A CDC-vel való munkavégzéshez oktális kellett
6600 nagygép, amelynek szómérete 60 bit volt. Ha tudna olvasni
oktális, akkor egy szót 20 számjegyűnek tekinthet. Két számjegy van ábrázolva
az op kód, és egy számjegy azonosította a 8 regiszter egyikét. Közben
lassú átmenet volt a gépi kódokról a magas szintű nyelvekre, ez volt
hasznosnak tartják oktális formák biztosítását a programozási nyelvekben.
A C-ben az oktalitás rendkívül szerencsétlen ábrázolása volt
kiválasztva: Vezető nulla. Tehát C-ben az 0100 64-et jelent, nem 100-at, a 08 pedig egy
hiba, nem pedig 8. Még sajnos ez az anakronizmus volt
majdnem minden modern nyelvre másolva, beleértve a JavaScript-et is, ahol
csak hibák létrehozására szolgál. Nincs más célja. Tehát be
szigorú mód, oktális formák már nem engedélyezettek.
Stb
Az argumentumok pszeudo tömbje egy kicsit több lesz
tömbszerű az ES5-ben. Szigorú módban elveszíti hívóját és hívóját
tulajdonságait. Ez lehetővé teszi érveinek megbízhatatlanná tételét
kódot anélkül, hogy feladná a sok bizalmas kontextust. Továbbá a
argumentumok a funkciók tulajdonsága megszűnik.
Szigorú módban a függvény literálban lévő duplikált kulcsok a-t eredményeznek
szintaktikai hiba. A függvénynek nem lehet két azonos nevű paramétere.
A függvénynek nem lehet azonos nevű változója
paraméterek. A függvény nem tudja törölni a saját változóit. Kísérlet
egy nem konfigurálható tulajdonság törlése most kivételt hoz. Primitív
az értékek nincsenek implicit módon becsomagolva.
Foglalt szavak a jövőbeni JavaScript verziókhoz
Az ECMAScript 5 hozzáadja a fenntartott szavak listáját. Ha változóként vagy argumentumként használja őket, akkor a szigorú mód hibát okoz. A fenntartott szavak a következők:
eszközök, interfész, let, csomag, magán, védett, nyilvános, statikus és hozam
További irodalom
Szigorú mód - JavaScript | MDN
Böngésző támogatás a szigorú módhoz
Átállás szigorú módba
|
Határozottan ajánlom minden fejlesztőnek, hogy most kezdje el használni a szigorú módot. Elegendő böngésző támogatja azt, hogy a szigorú mód jogszerűen segít megmenteni minket azoktól a hibáktól, amelyekről nem is tudtuk, hogy a kódjában szerepelnek.
Nyilvánvaló, hogy a kezdeti szakaszban olyan hibák lesznek, amelyekkel még soha nem találkoztunk. A teljes előny elérése érdekében megfelelő tesztet kell végeznünk, miután szigorú módba váltottunk, hogy megbizonyosodjunk arról, hogy mindent elkaptunk. Határozottan nem csak szigorúan használjuk a kódot, és feltételezzük, hogy nincsenek hibák. Tehát a churn az, hogy itt az ideje elkezdeni használni ezt a hihetetlenül hasznos nyelvi funkciót a jobb kód megírásához.
Például,
var person = {
név: 'xyz',
pozíció: „abc”,
teljes név: function () {"use strict"; adja vissza ezt a nevet; }
};
A JSLint egy hibakereső, Douglas Crockford írta. Egyszerűen illessze be a szkriptet, és gyorsan megvizsgálja az észrevehető problémákat és hibákat a kódban.
|
Szeretnék valamivel megalapozottabb választ kínálni, kiegészítve a többi választ. Reméltem, hogy a legnépszerűbb választ szerkesztem, de nem sikerült. Igyekeztem minél átfogóbbá és teljesebbé tenni.
További információt az MDN dokumentációjában talál.
"szigorúan alkalmazza" az ECMAScript 5-ben bevezetett irányelvet.
Az irányelvek hasonlóak a nyilatkozatokhoz, mégis eltérnek.
use use nem tartalmaz kulcsszavakat: Az irányelv egy egyszerű kifejezés, amely egy speciális karakterláncból áll (egy vagy kettő idézőjelben). Az ECMAScript 5-t nem implementáló JavaScript-motorok csupán egy kifejezést látnak mellékhatások nélkül. Várható, hogy az ECMAScript szabványok jövőbeli verziói valós kulcsszóként vezetik be a felhasználást; az idézetek ezáltal elavulnának.
use use csak a szkript vagy a függvény elején használható, vagyis minden más (valós) állítást meg kell előznie. Nem feltétlenül ez az első utasítás a függvény szkriptjében: megelőzhetők más utasításkifejezések, amelyek string literálokból (és JavaScript-ből állnak)a megvalósítások végrehajtás-specifikus irányelvként kezelhetik őket). Az első valós utasítás után (szkriptben vagy függvényben) szereplő karakterlánc-utasítások egyszerű kifejezés-utasítások. A tolmácsok nem értelmezhetik őket irányelvként, és ezeknek nincs hatásuk.
A szigorú használatról szóló irányelv azt jelzi, hogy a következő kód (szkriptben vagy függvényben) szigorú kód.
A parancsfájl legmagasabb szintjén lévő kód (az a kód, amely nem szerepel a függvényben) szigorú kódnak minősül, ha a parancsfájl tartalmaz szigorú használati utasítást.
A függvény tartalma akkor tekinthető szigorú kódnak, ha magát a függvényt egy szigorú kód határozza meg, vagy ha a függvény tartalmaz szigorú használati utasítást.
Az eval () metódusnak átadott kód akkor minősül szigorú kódnak, ha az eval () parancsot szigorú kódból hívták meg, vagy magát a szigorú használati utasítást tartalmazza.
Az ECMAScript 5 szigorú módja a JavaScript nyelv korlátozott részhalmaza, amely kiküszöböli a nyelv releváns hiányosságait, és szigorúbb hibajavítást és magasabb biztonságot kínál. Az alábbiakban felsoroljuk a szigorú és a normál mód közötti különbségeket (amelyek közül az első három különösen fontos):
Nem használhatja a with-utasítást szigorú módban.
Szigorú módban az összes változót deklarálni kell: ha hozzárendel egy értéket egy azonosítóhoz, amelyet nem deklaráltunk változóként, függvényként, függvényparaméterként, catch-clause paraméterként vagy a globális objektum tulajdonságaként, akkor kap egy ReferenceError-t. Normál módban az azonosítót implicit módon globális változóként deklaráljuk (a globális objektum tulajdonságaként)
Szigorú módban a kulcsszó ennek az értéknek nincs meghatározva azokban a függvényekben, amelyeket függvényként (és nem módszerként) hívtak meg. (Normál módban ez mindig a globális objektumra mutat). Ez a különbség használható annak tesztelésére, hogy egy megvalósítás támogatja-e a szigorú módot:
var hasStrictMode = (function () {"use strict"; adja vissza ezt === undefined} ());
Akkor is, ha egy függvényt hívással hívunk meg (), vagy szigorú módban alkalmazzuk, akkor ez pontosan a hívás () vagy az alkalmazás () meghívás első argumentumának értéke. (Normál módban a null és undefined helyébe a globális Objektum lép, és az értékek, amelyek nem objektumok, objektumokba kerülnek.)
Szigorú módban egy TypeError-t kap, amikor megpróbál csak olvasható tulajdonságokat rendelni vagy új tulajdonságokat definiálni egy nem bővíthető objektumhoz. (Normál módban mindkettő hibaüzenet nélkül egyszerűen meghibásodik.)
Szigorú módban, amikor kódot ad át az eval () -nak, nem tudja deklarálni vagy definiálni a változókat vagy a függvényeket a hívó körében (ahogy ezt normál módban megteheti). Ehelyett egy új hatókör jön létre az eval () számára, és a változók és függvények ezen a körön belül vannak. Ez a hatókör megsemmisül, miután az eval () befejezte a végrehajtást.
Szigorú módban a függvény argumentum-objektuma az értékek statikus másolatát tartalmazza, amelyek átadódnak annak a függvénynek. Normál üzemmódban az argumentum-objektum kissé "varázslatos" viselkedéssel rendelkezik: A tömb elemei és a megnevezett függvényparaméterek ugyanazon értékre hivatkoznak.
Szigorú módban kapsz egy SyntaxError-t, amikor a törlés operátort nem minősített azonosító (változó, függvény vagy függvényparaméter) követi. Normál üzemmódban a törlés kifejezés semmit sem tenne, és hamisra értékeli.
Szigorú módban TypeError-t kap, amikor megpróbál törölni egy nem konfigurálható tulajdonságot. (Normál módban a kísérlet egyszerűen kudarcot vall, és a törlés kifejezést hamisnak értékeli).
Szigorú módban szintaktikai hibának számít, amikor egy objektum literáljához több tulajdonságot próbál megadni azonos névvel. (Normál módban nincs hiba.)
Szigorú módban szintaktikai hibának számít, ha egy függvénydeklarációnak több, azonos nevű paramétere van. (Normál módban nincs hiba.)
Szigorú módban az oktális literálok nem engedélyezettek (ezek 0x-al kezdődő literálok. (Normál módban egyes megvalósítások megengedik az oktális literálokat).
Szigorú módban az eval azonosítókat és az argumentumokat kulcsszavakként kezeljük. Nem változtathatja meg az értéküket, nem rendelhet hozzájuk értéket, és nem használhatja őket változók, függvények, függvényparaméterek vagy a fogási blokk azonosítóinak neveként.
Szigorú módban több korlátozás vonatkozik a hívásverem vizsgálatának lehetőségeire. Az argumentumok.hívó és az argumentumok.hallek egy TypeError-t okoznak egy függvényben szigorú módban. Ezenkívül a függvények egyes hívó- és argumentumtulajdonságai szigorú módban TypeError-t okoznak, amikor megpróbálja elolvasni őket.
|
Két centem:
A szigorú mód egyik célja, hogy lehetővé tegye a problémák gyorsabb hibakeresését. Ez segít a fejlesztőknek abban, hogy kivételeket vet fel bizonyos rossz dolgok előfordulása esetén, amelyek csendes és furcsa viselkedést okozhatnak a weboldalán. Abban a pillanatban, amikor szigorúan használjuk, a kód hibákat dob ​​ki, amelyek segítenek a fejlesztőben előre javítani.
Néhány fontos dolog, amit megtanultam a szigorú használat után:
Megakadályozza a globális változó deklarációt:
var tree1Data= {név: 'Banánfa', kor: 100, levélszám: 100000};
függvényfa (typeOfTree) {
var age;
var leafCount;
age = typeOfTree.age;
leafCount = typeOfTree.leafCount;
nameoftree = typeOfTree.name;
};
var tree1 = új fa (tree1Data);
console.log (ablak);
Most ez a kód globálisan létrehozza a név nélküli nevet, amelyet az window.nameoftree használatával lehet elérni. Ha szigorúan alkalmazzuk a felhasználást, a kód hibát okozhat.
El nem fogott ReferenceError: a nameoftree nincs meghatározva
Minta
Megszünteti a következővel:
utasításokkal nem lehet minimalizálni olyan eszközökkel, mint az uglify-js. Ezenkívül elavultak és eltávolításra kerülnek a jövőbeli JavaScript verziókból.
Minta
Megakadályozza az ismétléseket:
Ha duplikált tulajdonságunk van, kivételt vet
El nem fogott SyntaxError: Az objektum szó szerinti adat tulajdonságának duplikálása nem
szigorú módban engedélyezett
"használja szigorúan";
var tree1Data = {
név: „Banánfa”,
életkor: 100,
leafCount: 100000,
név: „Banánfa”
};
Kevesebb van még, de erről több ismeretet kell szereznem.
|
Ha olyan böngészőt használ, amely az elmúlt évben megjelent, akkor valószínűleg támogatja a JavaScript szigorú módját. Csak azok a régebbi böngészők nem támogatják, mielőtt az ECMAScript 5 lett az aktuális szabvány.
A parancs körüli idézetek biztosítják, hogy a kód továbbra is működjön a régebbi böngészőkben is (bár azok a dolgok, amelyek szigorú módban szintaktikai hibát generálnak, általában csak a parancsfájl hibás működését okozzák bizonyos régebben használt böngészőkben).
|
A "use strict";;
Kövezzük az utat a jövőbeli ECMAScript verziók számára, az újonnan lefoglalt kulcsszavak egyikével (előbb az ECMAScript 6 esetében): eszközök, felület, let, csomag, magán, védett, nyilvános, statikus és hozam.
Funkció deklarálása blokkokban
if (a : 3: 15)
itt: : 6: 5
Itt a fordító dobja a referencia hibát. Szigorú módban a fordító nem engedélyezi a változó használatát deklarálás nélkül. Tehát a memória szivárgása megakadályozható. Ezen felül írhatunk optimalizáltabb kódot is.
|
A szigorú mód kiküszöböli azokat a hibákat, amelyeket nem szigorú módban figyelmen kívül hagynának, így a javascript „biztonságosabbá” válik.
A bevált gyakorlatok között szerepel-e?
Igen, a legjobb gyakorlatok részének tekintik, miközben a javascript-lel dolgozunk a Szigorú mód beillesztésében. Ez az alábbi kódsor hozzáadásával történik a JS fájlban.
„szigorúan használja”;
a kódodban.
Mit jelent a felhasználói ügynökök számára?
Annak jelzése, hogy a kódot szigorúan kell értelmezni, meghatározza a felhasználói ügynököknek, például a böngészőknek, hogy a kódot szó szerint írottként kell kezelniük, és hibát kell okozniuk, ha a kódnak nincs értelme.
Például: Fontolja meg a .js fájlban a következő kódot:
1. forgatókönyv: [NEM SZIGORÚ MÓD]
var city = "Chicago"
console.log (város) // Kiírja a város nevét, azaz Chicago
2. forgatókönyv: [NEM SZIGORÚ MÓD]
város = "Chicago"
console.log (város) // Kiírja a város nevét, azaz Chicagót
Tehát miért nyomtatják a változó nevét mindkét esetben?
A szigorú mód bekapcsolása nélkül a felhasználói ügynökök gyakran módosító sorozatokat hajtanak végre a problémás kódban annak érdekében, hogy értelmessé váljanak. A felszínen ez remek dolognak tűnhet, és valóban, a szigorú módon kívüli munkavégzés lehetővé teszi, hogy az emberek nedvesítsék a lábukat JavaScript-kóddal anélkül, hogy minden részletet eléggé szögeznének le. Fejlesztőként azonban nem akarok hibát hagyni a kódomban, mert tudom, hogy ez később visszatérhet és megharaphat, és csak jó kódot is szeretnék írni. És itt segít a szigorú mód.
3. forgatókönyv: [SZIGOROS MÓD]
„szigorúan használja”;
város = "Chicago"
console.log (város) // Referencia hiba: a hozzárendelés nem bejelentett változó város.
További tipp: A szigorú módú kódminőség fenntartásához nem kell ezt újra és újra írni, különösen, ha több .js fájlja van. Ezt a szabályt globálisan érvényesítheti az eslint-szabályokban az alábbiak szerint:
Fájlnév: .eslintrc.js
module.exports = {
env: {
es6: igaz
},
szabályok: {
szigorú: ['hiba', 'globális'],
},
};
Oké, akkor mit akadályoz meg szigorú módban?
Egy változó használata deklarálás nélkül hibát okoz a szigorú módban. Ez megakadályozza a globális változók véletlenszerű létrehozását az alkalmazásban. A Chicago nyomtatásával kapcsolatos példa különösen ezt fedi le.
Változó, függvény vagy argumentum törlése szigorú módban nem-nem.
"használja szigorúan";
x függvény (p1, p2) {};
x törlése; // Ez hibát fog okozni
Szigorú módban nem engedélyezett a paraméternév másolása.
"használja szigorúan";
x függvény (p1, p1) {}; // Ez hibát fog okozni
A Javascript nyelvű fenntartott szavak nem engedélyezettek szigorú módban. A szavak az interfész, let, csomagok, privát, védett, nyilvánosak. statikus és hozam
Az átfogóbb listához nézze meg az MDN dokumentációját itt: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
|
Nagyon aktív kérdés. Nyerjen 10 hírnevet a kérdés megválaszolásához. A jó hírnév követelménye megvédi ezt a kérdést a spamektől és a nem válaszolóktól.
Nem a keresett válasz? Böngésszen a javascript szintaxis jslint use-strict címkével ellátott többi kérdésben, vagy tegye fel saját kérdését.